
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package managedBean;

import entities.Album;
import entities.Artiste;
import entities.Chanson;
import java.io.File;
import java.io.Serializable;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.inject.Named;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.swing.text.Document;
import org.blinkenlights.jid3.MP3File;
import org.blinkenlights.jid3.MediaFile;
import org.primefaces.model.DefaultTreeNode;
import org.primefaces.model.TreeNode;
import rumbleToolkit.Mp3AnalyzerTool;
import session.AlbumManager;
import session.ArtisteManager;
import session.ChansonManager;

/**
 *
 * @author Nordinator
 */
@Named(value = "mp3LibraryMBean")
//@Dependent
@ManagedBean
@SessionScoped
public class Mp3LibraryMBean implements Serializable{
    
    
    @EJB
    private ChansonManager chansonManager;
    private List<Chanson> listChanson;
    @EJB
    private ArtisteManager artisteManager;
    private TreeNode rootArtiste;
    private Document selectedDocument;
    @EJB
    private AlbumManager albumManager;
    
    private static final Logger logger = Logger.getLogger(Mp3LibraryMBean.class.getName());
    private String index = "home";
    private static String path;
    private String localAdresse;
    private String pathServer ;
    private String filtre = "(.*).mp3";
    
    /** Creates a new instance of UserManagedBean */
    public Mp3LibraryMBean() {
        try{
            InetAddress address = InetAddress.getLocalHost();
            localAdresse=address.getHostAddress();
            pathServer = "http://"+localAdresse+":8080/Project-MP3-Rumble-war/MP3Servelet";
        }catch(Exception e){
                    
        }
    }
    
    public String getPath(){
        return path;
    }
    
    public void setPath(String path){
        System.out.println("Nouveau Path : "+path);
        this.path=path;
    }
    
    public List<Chanson> getListChanson(){
        for(Chanson sg : listChanson){
            System.out.println("Pwet : "+sg);
        }
        return listChanson;
    }
        /**
     * Methode de récupération des chansons
     * @return 
     */
    public List<Chanson> getDetailsSong() {
        if (listChanson == null) {
            listChanson = chansonManager.getAllSongs();
            //a modifier pour rediriger vers un site
        }
        System.out.println(listChanson);
        return listChanson;
    }
    
    
    public TreeNode getRootArtiste(){
        this.getTreeArtiste();
        return rootArtiste;
    }
    
    public Document getSelectedDocument() {  
        return selectedDocument;  
    }  
    
    public void setSelectedDocument(Document selectedDocument) {  
        this.selectedDocument = selectedDocument;  
    }
    
    /**
     * Handler de récuperation des artistes
     * @return artiste
     */
    
    
    public void getTreeArtiste(){
        rootArtiste = new DefaultTreeNode("root", null);
        List<Artiste> listArtiste = artisteManager.getAllArtistes();
        for(Artiste art : listArtiste){
            TreeNode tmpArtiste = new DefaultTreeNode(art, rootArtiste);
            for(Album alb : art.getDiscographie()){
                    TreeNode tmpAlbum = new DefaultTreeNode(alb, tmpArtiste);
                    for(Chanson song : alb.getAlbumSongs()){
                        TreeNode tmpSong = new DefaultTreeNode(song, tmpAlbum);
                    }
            }
        }
    }

    //Zone qui concerne la gestion de l'arbre des chansons
    static private TreeNode selectedNode;
    
    public TreeNode getSelectedNode() {  
        return selectedNode;  
    }  
    
    public void setSelectedNode(TreeNode selectedNode) {
        System.out.println(selectedNode);
        this.selectedNode = selectedNode; 
    }
    /**
     * 
     */
    public static List<Chanson> sl;
    
    public List<Chanson> getSl(){
        return sl;
    }
    
    /**
     * Methode qui permet de charger des chansons de l'arbre de selection
     * @param
     */
    public String treePlayerLoader(){
        sl = new ArrayList<Chanson>();
        if(selectedNode.getData() instanceof Artiste){
            Artiste art = (Artiste) selectedNode.getData();
            for(Album alb : art.getDiscographie()){
                for(Chanson song : alb.getAlbumSongs()){
                    sl.add(song);
                }
            }
        }else if(selectedNode.getData() instanceof Album){
            Album alb = (Album) selectedNode.getData();
            for(Chanson song : alb.getAlbumSongs()){
                sl.add(song);
            }
        }else if(selectedNode.getData() instanceof Chanson){
            sl.add((Chanson) selectedNode.getData());
        }
        //TODO : Ajouter la redirection
        return "browserPlayer"+"?faces-redirect=true";
    }
    
    /**
     * Cette méthode scan le dossier courant et inscript les
     * @return
     */
    public String folderAnalyser() {
        //Analyser de l'url afin de déceler les fichiers mp3
        Pattern p = Pattern.compile(filtre);
        String[] s = new File(path.replace("/", "\\")).list();
        int errorMP3File = 0;
        Hashtable<String, Artiste> art = new Hashtable<String, Artiste>();
        Hashtable<String, Album> alb = new Hashtable<String, Album>();
        List<Chanson> sg = new ArrayList<Chanson>();
        for (int i = 0; i < s.length; i++) {
            //verification de l'extension .mp3
            Matcher m = p.matcher(s[i]);
            if (m.matches()) {
                //Creation et enregistrement dans la base de donnée
                File oSourceFile = new File(path + s[i]);
                MediaFile oMediaFile = new MP3File(oSourceFile);
                Hashtable<String, String> listTag = Mp3AnalyzerTool.mp3analyzer(oMediaFile);
                if (!listTag.isEmpty()) {
                    String ulr = pathServer +"?file="+ path + "/" +s[i];
                    Chanson song = new Chanson(listTag.get("title"), ulr, 
                            (listTag.containsKey("genre")) ? listTag.get("genre") : "Inconnue");
                    Artiste artiste = new Artiste((listTag.containsKey("artiste") || listTag.get("artiste").equals("")) ? listTag.get("artiste") : "Inconnue");
                    Album album = new Album((listTag.containsKey("album") || listTag.get("album").equals("")) ? listTag.get("album") : "Inconnue");
                    
                    //Ajouter un album
                    if (!alb.containsKey(album.getName())) {
                        album.addSong(song);
                        alb.put(album.getName(), album);
                        //Oublie pas de dire a chanson qu'il a un album
                        song.addAlbum(album);
                    } else {
                        alb.get(album.getName()).addSong(song);
                        song.addAlbum(alb.get(album.getName()));
                    }

                    //Ajouter un artiste
                    if (!art.containsKey(artiste.getName())) {
                        artiste.addAlbum(album);
                        art.put(artiste.getName(), artiste);
                        song.addArtiste(artiste);
                    } else {
                        if (!art.get(artiste.getName()).containAlbum(album.getName())) {
                            art.get(artiste.getName()).addAlbum(album);
                        }
                        song.addArtiste(art.get(artiste.getName()));
                    }
                } else {
                    errorMP3File++;
                }
            }
        }
        
        //Phenomene : avec la cascade tout est enregistré avec cette fonction
        for (Artiste artiste : art.values()) {
            //System.out.println(artiste);
            try{
                artisteManager.ajouterArtiste(artiste);
            }catch(Exception e){
                System.out.println("Marche po!");
            }
        }

        System.out.println("Il y a " + errorMP3File + " non prise en charge !");
        return index;
    }
    
    /**
     * Methode de test de fonction
     */
    public String test() {
        this.folderAnalyser();
        return index;
    }
}
